import fs from "fs/promises"
import inquirer from "inquirer"
import path from "path"
import {含其中之一} from 'amtf/utils/数组';
let 当前项目
// const 排除文件夹名组 = ["基础", "开发"]
// const 排除文件名组 = ["基础.ts", "开发.ts", "list.vue"]
// const 排除文件名组 = ["基础", "开发", "list"]
const 排除文件名组 = ["基础", "jichu", "开发", "dev"]

const getFolders = async () => {
    try {
        const files = await fs.readdir("./项目")
        const folders = []
        for (const file of files) {
            const stats = await fs.stat(path.join("./项目", file))
            if (stats.isDirectory()) {
                folders.push(file)
            }
        }
        return folders
    } catch (err) {
        throw err
    }
}

const 显示文件夹选择列表 = async folders => {
    const questions = [
        {
            type: "list",
            name: "selectedFolder",
            message: "请选择一个文件夹:",
            choices: folders,
        },
    ]

    const answers = await inquirer.prompt(questions)
    return answers.selectedFolder
}

const 创建软链接 = async (源文件, 软链接文件) => {
    源文件 = path.resolve(源文件)
    // console.log(`源文件 👉`, 源文件)
    软链接文件 = path.resolve(软链接文件)
    try {
        await fs.lstat(软链接文件)
        await fs.unlink(软链接文件)
        console.log(`删除现有 软链接文件 👉`, 软链接文件)
    } catch (error) {
        if (error.code !== "ENOENT") {
            console.error(`删除软链接时出错: ${error.message}`)
            throw error
        }
    }

    // 判断源路径是文件还是文件夹
    const stats = await fs.stat(源文件)
    const type = stats.isDirectory() ? "dir" : "file"
    await fs.symlink(源文件, 软链接文件, type)
    console.log(`创建 软链接文件 👉`, 软链接文件)
}

async function 转移手动挡文件_单个(文件名) {
    // const 全名=path.resolve(文件.)
    const isSymlink = await fs.lstat(文件名).then(stat => stat.isSymbolicLink())
    if (!isSymlink) {
        const relativePath = path.relative(process.cwd(), 文件名)
        const targetDir = path.join("./项目", 当前项目, relativePath)
        await fs.mkdir(targetDir, { recursive: true })
        const targetPath = path.join(targetDir, entry.name)
        await fs.rename(文件名, targetPath)
        // 将路径转换为绝对路径
        const 源文件 = path.resolve(targetPath)
        const 软链接文件 = path.resolve(文件名)
        await 创建软链接(源文件, 软链接文件)
    }
}

async function 转移手动挡文件_仅顶层(dir, 排除文件名组) {
    const entries = await fs.readdir(dir, { withFileTypes: true })
    // let 文件组=[]
    for (const entry of entries) {
        // const 全名 = path.join(process.cwd(), dir, entry.name)
        if (entry.isFile() && !排除文件名组.some(excluded => entry.name.includes(excluded))) {
            // 文件组.push(entry.)
            转移手动挡文件_单个(entry.path)
        }
    }
    // return 文件组
}

async function 存手动挡文件_遍历文件夹(dir) {
    const entries = await fs.readdir(dir, { withFileTypes: true })
    for (const entry of entries) {
        const 手动挡文件或夹 = path.join(dir, entry.name)
        const 无后缀文件名 = path.parse(entry.name).name
        // if (排除文件名组.includes(无后缀文件名)) continue
        if (含其中之一(无后缀文件名, 排除文件名组)) continue
        if (entry.isDirectory()) {
            await 存手动挡文件_遍历文件夹(手动挡文件或夹)
        } else {
            // 创建软链接的方式作废，不方便复制成一个不同的文件下
            // const isSymlink = await fs.lstat(手动挡文件或夹).then(stat => stat.isSymbolicLink())
            // if (!isSymlink) {
            //     // const relativePath = path.relative(process.cwd(), dir)
            //     // const 项目库对应路径 = path.join("./项目", 当前项目, relativePath)
            //     const 项目库对应路径 = path.join("项目", 当前项目, dir)
            //     await fs.mkdir(项目库对应路径, { recursive: true })
            //     const 项目库文件 = path.join(项目库对应路径, entry.name)
            //     // await fs.rename(手动挡文件或夹, 项目库文件)
            //     await fs.copyFile(手动挡文件或夹, 项目库文件);
            //     // console.log(`转移到项目库 手动挡文件或夹 👉`, 手动挡文件或夹)
            //     // await 创建软链接(项目库文件, 手动挡文件或夹)
            // }

            const 项目库对应路径 = path.join("项目", 当前项目, dir)
            await fs.mkdir(项目库对应路径, { recursive: true })
            const 项目库文件 = path.join(项目库对应路径, entry.name)
            await fs.copyFile(手动挡文件或夹, 项目库文件)
        }
    }
}

async function 清手动挡(dir) {
    const entries = await fs.readdir(dir, { withFileTypes: true })
    for (const entry of entries) {
        const 无后缀文件名 = path.parse(entry.name).name
        // if (排除文件名组.includes(无后缀文件名)) continue
        if (含其中之一(无后缀文件名, 排除文件名组)) continue
        const fullPath = path.join(dir, entry.name)
        console.log(`fullPath 👉`, fullPath)
        await fs.rm(fullPath, { recursive: true, force: true })
    }
}

async function 复制手动挡文件(dir) {
    const 源文件夹 = path.join("项目", 当前项目, dir)
    const entries = await fs.readdir(源文件夹, { withFileTypes: true })
    // const 项目库根路径 = path.join("项目", 当前项目, "\\")
    // const 链接根路径 = dir.replace(项目库根路径, "")
    // const 项目库对应路径 = path.join("项目", 当前项目, dir)
    for (const entry of entries) {
        // const 源文件或夹 = path.join("项目", 当前项目, dir, entry.name)
        const 链接路径 = path.join(dir, entry.name)
        if (entry.isDirectory()) {
            await fs.mkdir(链接路径, { recursive: true })
            await 复制手动挡文件(链接路径)
        } else {
            const 源文件 = path.join("项目", 当前项目, 链接路径)
            await fs.copyFile(源文件, 链接路径)
            // 链接手动挡文件_单个(链接路径)
            // await 创建软链接(源文件或夹, 链接路径)
        }
    }
}

async function 链接手动挡文件_单个(链接路径) {
    const 源文件 = path.join("项目", 当前项目, 链接路径)
    await 创建软链接(源文件, 链接路径)
}

async function 予手动挡文件(dir) {
    await 清手动挡(dir)
    // const 项目库对应路径 = path.join("项目", 当前项目, dir)
    await 复制手动挡文件(dir)
}

const main = async () => {
    const jsonData = await fs.readFile("./项目/当前项目.json", "utf8")
    当前项目 = JSON.parse(jsonData).当前项目
    console.log(`当前项目: ${当前项目}`)
    await 存手动挡文件_遍历文件夹("web/src/aa")
    await 存手动挡文件_遍历文件夹("server/aa")
    await 存手动挡文件_遍历文件夹("server/aa_json")
    await 存手动挡文件_遍历文件夹("server/aa_model")

    const { 是否切换 } = await inquirer.prompt([
        {
            type: "confirm",
            name: "是否切换",
            message: "是否切换项目?",
        },
    ])
    if (是否切换) {
        const folders = await getFolders()
        const selectedFolder = await 显示文件夹选择列表(folders)
        console.log(`你选择的文件夹是: ${selectedFolder}`)
        try {
            const jsonData = await fs.readFile("./项目/当前项目.json", "utf8")
            const data = JSON.parse(jsonData)
            当前项目 = selectedFolder
            data.当前项目 = 当前项目
            await fs.writeFile("./项目/当前项目.json", JSON.stringify(data, null, 2))
        } catch (error) {
            console.error("保存选择的项目信息出错:", error)
        }
    }

    await 予手动挡文件("web/src/aa")
    await 予手动挡文件("server/aa")
    await 予手动挡文件("server/aa_json")
    await 予手动挡文件("server/aa_model")

    链接手动挡文件_单个("web/src/config.ts")
    链接手动挡文件_单个("web-user/src/config.ts")
    链接手动挡文件_单个("server/config.yaml")
}

main()

// function 含其中之一(str, 关键词组, 包含关系 = true) {
//     // console.log('含其中之一 str: ', str);
//     const 含 = 关键词组.some(item => {
//         // console.log('关键词: ', item);
//         if (包含关系) {
//             return str.includes(item)
//         } else {
//             return str == item
//         }
//     })
//     // console.log('含: ', 含);
//     return 含
// }